home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_xemacs.idb / usr / freeware / lib / xemacs-20.4 / lisp / modes / vrml-mode.el.z / vrml-mode.el
Encoding:
Text File  |  1998-05-21  |  26.1 KB  |  785 lines
  1. ;;; vrml-mode.el --- major mode for editing VRML (.wrl) files
  2.  
  3. ;; Copyright (C) 1994 Free Software Foundation, Inc.
  4. ;; Copyright (C) 1996 Ben Wing.
  5.  
  6. ;; Author: Ben Wing <wing@666.com>
  7. ;; Keywords: languages vrml modes
  8.  
  9. ;; This file is part of XEmacs.
  10.  
  11. ;; XEmacs is free software; you can redistribute it and/or modify it
  12. ;; under the terms of the GNU General Public License as published by
  13. ;; the Free Software Foundation; either version 2, or (at your option)
  14. ;; any later version.
  15.  
  16. ;; XEmacs is distributed in the hope that it will be useful, but
  17. ;; WITHOUT ANY WARRANTY; without even the implied warranty of
  18. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19. ;; General Public License for more details.
  20.  
  21. ;; You should have received a copy of the GNU General Public License
  22. ;; along with XEmacs; see the file COPYING.  If not, write to the 
  23. ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24. ;; Boston, MA 02111-1307, USA.
  25.  
  26. ;;; Synched up with: Not in FSF.
  27.  
  28. ;;; Commentary:
  29.  
  30. ;; Mostly bastardized from tcl.el.
  31.  
  32. ;; HOW TO INSTALL:
  33. ;; Put the following forms in your .emacs to enable autoloading of VRML
  34. ;; mode, and auto-recognition of ".wrl" files.
  35. ;;
  36. ;;   (autoload 'vrml-mode "vrml" "VRML mode." t)
  37. ;;   (setq auto-mode-alist (append '(("\\.wrl\\'" . vrml-mode))
  38. ;;                   auto-mode-alist))
  39. ;;
  40.  
  41. ;;; Code:
  42.  
  43. ;;
  44. ;; User variables.
  45. ;;
  46.  
  47. (defgroup vrml nil
  48.   "Major mode for editing VRML (.wrl) files."
  49.   :group 'languages)
  50.  
  51.  
  52. (defcustom vrml-indent-level 3
  53.   "*Indentation of VRML statements with respect to containing block."
  54.   :type 'integer
  55.   :group 'vrml)
  56.  
  57. (defcustom vrml-auto-newline nil
  58.   "*Non-nil means automatically newline before and after braces
  59. inserted in VRML code."
  60.   :type 'boolean
  61.   :group 'vrml)
  62.  
  63. (defcustom vrml-tab-always-indent t
  64.   "*Control effect of TAB key.
  65. If t (the default), always indent current line.
  66. If nil and point is not in the indentation area at the beginning of
  67. the line, a TAB is inserted.
  68. Other values cause the first possible action from the following list
  69. to take place:
  70.  
  71.   1. Move from beginning of line to correct indentation.
  72.   2. Delete an empty comment.
  73.   3. Move forward to start of comment, indenting if necessary.
  74.   4. Move forward to end of line, indenting if necessary.
  75.   5. Create an empty comment.
  76.   6. Move backward to start of comment, indenting if necessary."
  77.   :type '(choice (const :tag "on" t)
  78.          (const :tag "off" nil)
  79.          (sexp :format "%t\n" :tag "The Works" other))
  80.   :group 'vrml)
  81.  
  82. (defcustom vrml-use-hairy-comment-detector t
  83.   "*If not `nil', then the more complicated, but slower, comment
  84. detecting function is used."
  85.   :type 'boolean
  86.   :group 'vrml)
  87.  
  88. (defvar vrml-mode-abbrev-table nil
  89.   "Abbrev table used while in VRML mode.")
  90. (define-abbrev-table 'vrml-mode-abbrev-table ())
  91.  
  92. (defvar vrml-mode-map ()
  93.   "Keymap used in VRML mode.")
  94. (if (null vrml-mode-map)
  95.     (progn
  96.       (setq vrml-mode-map (make-sparse-keymap))
  97.       (set-keymap-name vrml-mode-map 'vrml-mode-map)
  98.       (define-key vrml-mode-map "{" 'vrml-electric-brace)
  99.       (define-key vrml-mode-map "}" 'vrml-electric-brace)
  100.       (define-key vrml-mode-map "\e\C-q" 'indent-vrml-exp)
  101.       (define-key vrml-mode-map "\t" 'vrml-indent-command)
  102.       (define-key vrml-mode-map "\M-;" 'vrml-indent-for-comment)
  103.       ))
  104.  
  105. (defvar vrml-mode-syntax-table nil
  106.   "Syntax table in use in vrml-mode buffers.")
  107.  
  108. (if vrml-mode-syntax-table
  109.     ()
  110.   (setq vrml-mode-syntax-table (make-syntax-table))
  111.   (modify-syntax-entry ?\n ">" vrml-mode-syntax-table)
  112.   (modify-syntax-entry ?\f ">" vrml-mode-syntax-table)
  113.   (modify-syntax-entry ?\# "<" vrml-mode-syntax-table)
  114.   (modify-syntax-entry ?\\ "\\" vrml-mode-syntax-table)
  115.   (modify-syntax-entry ?%  "_" vrml-mode-syntax-table)
  116.   (modify-syntax-entry ?@  "_" vrml-mode-syntax-table)
  117.   (modify-syntax-entry ?&  "_" vrml-mode-syntax-table)
  118.   (modify-syntax-entry ?*  "_" vrml-mode-syntax-table)
  119.   (modify-syntax-entry ?-  "_" vrml-mode-syntax-table)
  120.   (modify-syntax-entry ?:  "_" vrml-mode-syntax-table)
  121.   (modify-syntax-entry ?!  "_" vrml-mode-syntax-table)
  122.   (modify-syntax-entry ?$  "_" vrml-mode-syntax-table)
  123.   (modify-syntax-entry ?/  "_" vrml-mode-syntax-table)
  124.   (modify-syntax-entry ?~  "_" vrml-mode-syntax-table)
  125.   (modify-syntax-entry ?<  "_" vrml-mode-syntax-table)
  126.   (modify-syntax-entry ?=  "_" vrml-mode-syntax-table)
  127.   (modify-syntax-entry ?>  "_" vrml-mode-syntax-table)
  128.   (modify-syntax-entry ?|  "_" vrml-mode-syntax-table)
  129.   (modify-syntax-entry ?+ "." vrml-mode-syntax-table)
  130.   (modify-syntax-entry ?\' "\"" vrml-mode-syntax-table))
  131.  
  132. (defcustom vrml-mode-hook nil
  133.   "Hook run on entry to VRML mode."
  134.   :type 'hook
  135.   :group 'vrml)
  136.  
  137. (defvar vrml-keyword-list
  138.   '(
  139.     ; shape nodes:
  140.     "AsciiText" "Cone" "Cube" "Cylinder" "IndexedFaceSet" "IndexedLineSet"
  141.     "PointSet" "Sphere"
  142.     ; geometry and material nodes:
  143.     "Coordinate3" "FontStyle" "Info" "LOD" "Material" "MaterialBinding"
  144.     "Normal" "NormalBinding" "Texture2" "Texture2Transform"
  145.     "TextureCoordinate2" "ShapeHints"
  146.     ; transformation nodes:
  147.     "MatrixTransform" "Rotation" "Scale" "Transform" "Translation"
  148.     ;camera nodes:
  149.     "OrthographicCamera" "PerspectiveCamera"
  150.     ;lighting nodes:
  151.     "DirectionalLight" "PointLight" "SpotLight"
  152.     ;group nodes:
  153.     "Group" "Separator" "Switch" "TransformSeparator" "WWWAnchor"
  154.     ;other:
  155.     "WWWInline"
  156.     ;new VRML 2.0 nodes (#### not yet classified)
  157.     "Anchor" "Appearance" "AudioClip" "Background" "Billboard" "Box"
  158.     "Collision" "Color" "ColorInterpolator" "Coordinate"
  159.     "CoordinateInterpolator" "CylinderSensor" "DiskSensor" "ElevationGrid"
  160.     "Extrusion" "Fog" "FontStyle" "ImageTexture" "Inline" "MovieTexture"
  161.     "NavigationInfo" "NormalInterpolator" "OrientationInterpolator"
  162.     "PixelTexture" "PlaneSensor" "PositionInterpolator" "ProximitySensor"
  163.     "ScalarInterpolator" "Script" "Shape" "Sound" "SphereSensor" "Text"
  164.     "TextureTransform" "TextureCoordinate" "TimeSensor" "TouchSensor"
  165.     "Viewpoint" "VisibilitySensor" "WorldInfo"
  166.     ;VRML 2.0 node fields
  167.     "eventIn" "eventOut" "field" "exposedField"
  168.     ;misc. VRML 2.0 keywords (DEF, PROTO, EXTERNPROTO handled below)
  169.     "USE" "ROUTE" "TO" "IS" "TRUE" "FALSE" "NULL"
  170. ))
  171.  
  172. (defconst vrml-font-lock-keywords
  173.   (list
  174.    ;; Names of functions (and other "defining things").
  175.    (list "\\(DEF\\|PROTO\\|EXTERNPROTO\\)[ \t\n]+\\([^ \t\n]+\\)"
  176.      2 'font-lock-function-name-face)
  177.  
  178.    ;; Keywords.  Only recognized if surrounded by whitespace.
  179.    ;; FIXME consider using "not word or symbol", not
  180.    ;; "whitespace".
  181.    (cons (concat "\\(\\s-\\|^\\)\\("
  182.          ;; FIXME Use regexp-quote? 
  183.          (mapconcat 'identity vrml-keyword-list "\\|")
  184.          "\\)\\(\\s-\\|$\\)")
  185.      2)
  186.    )
  187.   "Keywords to highlight for VRML.  See variable `font-lock-keywords'.")
  188.  
  189. ;;;###autoload
  190. (defun vrml-mode ()
  191.   "Major mode for editing VRML code.
  192. Expression and list commands understand all VRML brackets.
  193. Tab indents for VRML code.
  194. Paragraphs are separated by blank lines only.
  195. Delete converts tabs to spaces as it moves back.
  196.  
  197. Variables controlling indentation style:
  198.   vrml-indent-level
  199.     Indentation of VRML statements within surrounding block.
  200.  
  201. Variables controlling user interaction with mode (see variable
  202. documentation for details):
  203.   vrml-tab-always-indent
  204.     Controls action of TAB key.
  205.   vrml-auto-newline
  206.     Non-nil means automatically newline before and after braces
  207.     inserted in VRML code.
  208.  
  209. Turning on VRML mode calls the value of the variable `vrml-mode-hook'
  210. with no args, if that value is non-nil.  Read the documentation for
  211. `vrml-mode-hook' to see what kinds of interesting hook functions
  212. already exist.
  213.  
  214. Commands:
  215. \\{vrml-mode-map}"
  216.   (interactive)
  217.   (kill-all-local-variables)
  218.   (use-local-map vrml-mode-map)
  219.   (setq major-mode 'vrml-mode)
  220.   (setq mode-name "VRML")
  221.   (setq local-abbrev-table vrml-mode-abbrev-table)
  222.   (set-syntax-table vrml-mode-syntax-table)
  223.  
  224.   (make-local-variable 'paragraph-start)
  225.   (make-local-variable 'paragraph-separate)
  226.   (if (fboundp 'move-to-left-margin)
  227.       (progn
  228.     ;; In FSF Emacs 19.29 / XEmacs 19.14, you aren't supposed to
  229.     ;; start these with a ^.
  230.     (setq paragraph-start "$\\| ")
  231.     (setq paragraph-separate paragraph-start))
  232.     (setq paragraph-start (concat "^$\\|" page-delimiter))
  233.     (setq paragraph-separate paragraph-start))
  234.   (make-local-variable 'paragraph-ignore-fill-prefix)
  235.   (setq paragraph-ignore-fill-prefix t)
  236.   (make-local-variable 'fill-paragraph-function)
  237.   (setq fill-paragraph-function 'vrml-do-fill-paragraph)
  238.  
  239.   (make-local-variable 'indent-line-function)
  240.   (setq indent-line-function 'vrml-indent-line)
  241.   (make-local-variable 'require-final-newline)
  242.   (setq require-final-newline t)
  243.  
  244.   (make-local-variable 'comment-start)
  245.   (setq comment-start "# ")
  246.   (make-local-variable 'comment-start-skip)
  247.   (setq comment-start-skip "#+ *")
  248.   (make-local-variable 'comment-column)
  249.   (setq comment-column 40)
  250.   (make-local-variable 'comment-end)
  251.   (setq comment-end "")
  252.  
  253.   (make-local-variable 'outline-regexp)
  254.   (setq outline-regexp "[^\n\^M]")
  255.   (make-local-variable 'outline-level)
  256.   (setq outline-level 'vrml-outline-level)
  257.  
  258.   (make-local-variable 'font-lock-keywords)
  259.   (setq font-lock-keywords vrml-font-lock-keywords)
  260.  
  261.   (make-local-variable 'parse-sexp-ignore-comments)
  262.   (setq parse-sexp-ignore-comments t)
  263.  
  264.   (make-local-variable 'defun-prompt-regexp)
  265.   (setq defun-prompt-regexp "^[^ \t\n#}][^\n}]+}*[ \t]+")
  266.  
  267.   ;; Settings for new dabbrev code.
  268.   (make-local-variable 'dabbrev-case-fold-search)
  269.   (setq dabbrev-case-fold-search nil)
  270.   (make-local-variable 'dabbrev-case-replace)
  271.   (setq dabbrev-case-replace nil)
  272.   (make-local-variable 'dabbrev-abbrev-skip-leading-regexp)
  273.   (setq dabbrev-abbrev-skip-leading-regexp "[$!]")
  274.   (make-local-variable 'dabbrev-abbrev-char-regexp)
  275.   (setq dabbrev-abbrev-char-regexp "\\sw\\|\\s_")
  276.  
  277.   (run-hooks 'vrml-mode-hook))
  278.  
  279. ;; This is used for closing braces.  If vrml-auto-newline is set, can
  280. ;; insert a newline both before and after the brace, depending on
  281. ;; context.  FIXME should this be configurable?  Does anyone use this?
  282. (defun vrml-electric-brace (arg)
  283.   "Insert character and correct line's indentation."
  284.   (interactive "p")
  285.   ;; If auto-newlining and there is stuff on the same line, insert a
  286.   ;; newline first.
  287.   (if vrml-auto-newline
  288.       (progn
  289.     (if (save-excursion
  290.           (skip-chars-backward " \t")
  291.           (bolp))
  292.         ()
  293.       (vrml-indent-line)
  294.       (newline))
  295.     ;; In auto-newline case, must insert a newline after each
  296.     ;; brace.  So an explicit loop is needed.
  297.     (while (> arg 0)
  298.       (insert last-command-char)
  299.       (vrml-indent-line)
  300.       (newline)
  301.       (setq arg (1- arg))))
  302.     (self-insert-command arg))
  303.   (vrml-indent-line))
  304.  
  305.  
  306.  
  307. (defun vrml-indent-command (&optional arg)
  308.   "Indent current line as VRML code, or in some cases insert a tab character.
  309. If vrml-tab-always-indent is t (the default), always indent current line.
  310. If vrml-tab-always-indent is nil and point is not in the indentation
  311. area at the beginning of the line, a TAB is inserted.
  312. Other values of vrml-tab-always-indent cause the first possible action
  313. from the following list to take place:
  314.  
  315.   1. Move from beginning of line to correct indentation.
  316.   2. Delete an empty comment.
  317.   3. Move forward to start of comment, indenting if necessary.
  318.   4. Move forward to end of line, indenting if necessary.
  319.   5. Create an empty comment.
  320.   6. Move backward to start of comment, indenting if necessary."
  321.   (interactive "p")
  322.   (cond
  323.    ((not vrml-tab-always-indent)
  324.     ;; Indent if in indentation area, otherwise insert TAB.
  325.     (if (<= (current-column) (current-indentation))
  326.     (vrml-indent-line)
  327.       (self-insert-command arg)))
  328.    ((eq vrml-tab-always-indent t)
  329.     ;; Always indent.
  330.     (vrml-indent-line))
  331.    (t
  332.     ;; "Perl-mode" style TAB command.
  333.     (let* ((ipoint (point))
  334.        (eolpoint (progn
  335.                (end-of-line)
  336.                (point)))
  337.        (comment-p (vrml-in-comment)))
  338.       (cond
  339.        ((= ipoint (save-excursion
  340.             (beginning-of-line)
  341.             (point)))
  342.     (beginning-of-line)
  343.     (vrml-indent-line)
  344.     ;; If indenting didn't leave us in column 0, go to the
  345.     ;; indentation.  Otherwise leave point at end of line.  This
  346.     ;; is a hack.
  347.     (if (= (point) (save-excursion
  348.              (beginning-of-line)
  349.              (point)))
  350.         (end-of-line)
  351.       (back-to-indentation)))
  352.        ((and comment-p (looking-at "[ \t]*$"))
  353.     ;; Empty comment, so delete it.  We also delete any ";"
  354.     ;; characters at the end of the line.  I think this is
  355.     ;; friendlier, but I don't know how other people will feel.
  356.     (backward-char)
  357.     (skip-chars-backward " \t;")
  358.     (delete-region (point) eolpoint))
  359.        ((and comment-p (< ipoint (point)))
  360.     ;; Before comment, so skip to it.
  361.     (vrml-indent-line)
  362.     (indent-for-comment))
  363.        ((/= ipoint eolpoint)
  364.     ;; Go to end of line (since we're not there yet).
  365.     (goto-char eolpoint)
  366.     (vrml-indent-line))
  367.        ((not comment-p)
  368.     (vrml-indent-line)
  369.     (vrml-indent-for-comment))
  370.        (t
  371.     ;; Go to start of comment.  We don't leave point where it is
  372.     ;; because we want to skip comment-start-skip.
  373.     (vrml-indent-line)
  374.     (indent-for-comment)))))))
  375.  
  376. (defun vrml-indent-line ()
  377.   "Indent current line as VRML code.
  378. Return the amount the indentation changed by."
  379.   (let ((indent (calculate-vrml-indent nil))
  380.     beg shift-amt
  381.     (case-fold-search nil)
  382.     (pos (- (point-max) (point))))
  383.     (beginning-of-line)
  384.     (setq beg (point))
  385.     (cond ((eq indent nil)
  386.        (setq indent (current-indentation)))
  387.       (t
  388.        (skip-chars-forward " \t")
  389.        (if (listp indent) (setq indent (car indent)))
  390.        (cond ((= (following-char) ?})
  391.           (setq indent (- indent vrml-indent-level)))
  392.          ((= (following-char) ?\])
  393.           (setq indent (- indent 1))))))
  394.     (skip-chars-forward " \t")
  395.     (setq shift-amt (- indent (current-column)))
  396.     (if (zerop shift-amt)
  397.     (if (> (- (point-max) pos) (point))
  398.         (goto-char (- (point-max) pos)))
  399.       (delete-region beg (point))
  400.       (indent-to indent)
  401.       ;; If initial point was within line's indentation,
  402.       ;; position after the indentation.  Else stay at same point in text.
  403.       (if (> (- (point-max) pos) (point))
  404.       (goto-char (- (point-max) pos))))
  405.     shift-amt))
  406.  
  407. (defun calculate-vrml-indent (&optional parse-start)
  408.   "Return appropriate indentation for current line as VRML code.
  409. In usual case returns an integer: the column to indent to.
  410. Returns nil if line starts inside a string, t if in a comment."
  411.   (save-excursion
  412.     (beginning-of-line)
  413.     (let* ((indent-point (point))
  414.        (case-fold-search nil)
  415.        state
  416.        containing-sexp
  417.        found-next-line)
  418.       (if parse-start
  419.       (goto-char parse-start)
  420.     (beginning-of-defun))
  421.       (while (< (point) indent-point)
  422.     (setq parse-start (point))
  423.     (setq state (parse-partial-sexp (point) indent-point 0))
  424.     (setq containing-sexp (car (cdr state))))
  425.       (cond ((or (nth 3 state) (nth 4 state))
  426.          ;; Inside comment or string.  Return nil or t if should
  427.          ;; not change this line
  428.          (nth 4 state))
  429.         ((null containing-sexp)
  430.          ;; Line is at top level.
  431.          0)
  432.         (t
  433.          (goto-char containing-sexp)
  434.          (let* ((expr-start (point)))
  435.            ;; Find the first statement in the block and indent
  436.            ;; like it.  The first statement in the block might be
  437.            ;; on the same line, so what we do is skip all
  438.            ;; "virtually blank" lines, looking for a non-blank
  439.            ;; one.  A line is virtually blank if it only contains
  440.            ;; a comment and whitespace.  We do it this funky way
  441.            ;; because we want to know if we've found a statement
  442.            ;; on some line _after_ the line holding the sexp
  443.            ;; opener.
  444.            (goto-char containing-sexp)
  445.            (forward-char)
  446.            (if (and (< (point) indent-point)
  447.             (looking-at "[ \t]*\\(#.*\\)?$"))
  448.            (progn
  449.              (forward-line)
  450.              (while (and (< (point) indent-point)
  451.                  (looking-at "[ \t]*\\(#.*\\)?$"))
  452.                (setq found-next-line t)
  453.                (forward-line))))
  454.            (if (not (or (= (char-after containing-sexp) ?{)
  455.                 (and (= (char-after containing-sexp) ?\[)
  456.                  (save-excursion
  457.                    (goto-char containing-sexp)
  458.                    (skip-chars-backward " \t\n")
  459.                    (forward-char -8)
  460.                    (looking-at "children")))))
  461.            (progn
  462.              ;; Line is continuation line, or the sexp opener
  463.              ;; is not a curly brace, or we are looking at
  464.              ;; an `expr' expression (which must be split
  465.              ;; specially).  So indentation is column of first
  466.              ;; good spot after sexp opener.  If there is no
  467.              ;; nonempty line before the indentation point, we
  468.              ;; use the column of the character after the sexp
  469.              ;; opener.
  470.              (if (>= (point) indent-point)
  471.              (progn
  472.                (goto-char containing-sexp)
  473.                (forward-char))
  474.                (skip-chars-forward " \t"))
  475.              (current-column))
  476.          ;; After a curly brace, and not a continuation line.
  477.          ;; So take indentation from first good line after
  478.          ;; start of block, unless that line is on the same
  479.          ;; line as the opening brace.  In this case use the
  480.          ;; indentation of the opening brace's line, plus
  481.          ;; another indent step.  If we are in the body part
  482.          ;; of an "if" or "while" then the indentation is
  483.          ;; taken from the line holding the start of the
  484.          ;; statement.
  485.          (if (and (< (point) indent-point)
  486.               found-next-line)
  487.              (current-indentation)
  488.            (if t ; commands-p
  489.                (goto-char expr-start)
  490.              (goto-char containing-sexp))
  491.            (+ (current-indentation) vrml-indent-level)))))))))
  492.  
  493.  
  494.  
  495. (defun indent-vrml-exp ()
  496.   "Indent each line of the VRML grouping following point."
  497.   (interactive)
  498.   (let ((indent-stack (list nil))
  499.     (contain-stack (list (point)))
  500.     (case-fold-search nil)
  501.     outer-loop-done inner-loop-done state ostate
  502.     this-indent last-sexp
  503.     (next-depth 0)
  504.     last-depth)
  505.     (save-excursion
  506.       (forward-sexp 1))
  507.     (save-excursion
  508.       (setq outer-loop-done nil)
  509.       (while (and (not (eobp)) (not outer-loop-done))
  510.     (setq last-depth next-depth)
  511.     ;; Compute how depth changes over this line
  512.     ;; plus enough other lines to get to one that
  513.     ;; does not end inside a comment or string.
  514.     ;; Meanwhile, do appropriate indentation on comment lines.
  515.     (setq inner-loop-done nil)
  516.     (while (and (not inner-loop-done)
  517.             (not (and (eobp) (setq outer-loop-done t))))
  518.       (setq ostate state)
  519.       (setq state (parse-partial-sexp (point) (progn (end-of-line) (point))
  520.                       nil nil state))
  521.       (setq next-depth (car state))
  522.       (if (and (car (cdr (cdr state)))
  523.            (>= (car (cdr (cdr state))) 0))
  524.           (setq last-sexp (car (cdr (cdr state)))))
  525.       (if (or (nth 4 ostate))
  526.           (vrml-indent-line))
  527.       (if (or (nth 3 state))
  528.           (forward-line 1)
  529.         (setq inner-loop-done t)))
  530.     (if (<= next-depth 0)
  531.         (setq outer-loop-done t))
  532.     (if outer-loop-done
  533.         nil
  534.       ;; If this line had ..))) (((.. in it, pop out of the levels
  535.       ;; that ended anywhere in this line, even if the final depth
  536.       ;; doesn't indicate that they ended.
  537.       (while (> last-depth (nth 6 state))
  538.         (setq indent-stack (cdr indent-stack)
  539.           contain-stack (cdr contain-stack)
  540.           last-depth (1- last-depth)))
  541.       (if (/= last-depth next-depth)
  542.           (setq last-sexp nil))
  543.       ;; Add levels for any parens that were started in this line.
  544.       (while (< last-depth next-depth)
  545.         (setq indent-stack (cons nil indent-stack)
  546.           contain-stack (cons nil contain-stack)
  547.           last-depth (1+ last-depth)))
  548.       (if (null (car contain-stack))
  549.           (setcar contain-stack 
  550.               (or (car (cdr state))
  551.               (save-excursion
  552.                 (forward-sexp -1)
  553.                 (point)))))
  554.       (forward-line 1)
  555.       (skip-chars-forward " \t")
  556.       (if (eolp)
  557.           nil
  558.         (if (and (car indent-stack)
  559.              (>= (car indent-stack) 0))
  560.         ;; Line is on an existing nesting level.
  561.         (setq this-indent (car indent-stack))
  562.           ;; Just started a new nesting level.
  563.           ;; Compute the standard indent for this level.
  564.           (let ((val (calculate-vrml-indent
  565.               (if (car indent-stack)
  566.                   (- (car indent-stack))))))
  567.         (setcar indent-stack
  568.             (setq this-indent val))
  569.         ))
  570.         (cond ((not (numberp this-indent)))
  571.           ((= (following-char) ?})
  572.            (setq this-indent (- this-indent vrml-indent-level)))
  573.           ((= (following-char) ?\])
  574.            (setq this-indent (- this-indent 1))))
  575.         ;; Put chosen indentation into effect.
  576.         (or (null this-indent)
  577.         (= (current-column) 
  578.            this-indent)
  579.         (progn
  580.           (delete-region (point) (progn (beginning-of-line) (point)))
  581.           (indent-to 
  582.            this-indent))))))))
  583.   )
  584.  
  585. ;;
  586. ;; Auto-fill support.
  587. ;;
  588.  
  589. (defun vrml-real-command-p ()
  590.   "Return nil if point is not at the beginning of a command.
  591. A command is the first word on an otherwise empty line, or the
  592. first word following an opening brace."
  593.   (save-excursion
  594.     (skip-chars-backward " \t")
  595.     (cond
  596.      ((bobp) t)
  597.      ((bolp)
  598.       (backward-char)
  599.       ;; Note -- continued comments are not supported here.  I
  600.       ;; consider those to be a wart on the language.
  601.       (not (eq ?\\ (preceding-char))))
  602.      (t
  603.       (memq (preceding-char) '(?{))))))
  604.  
  605. ;; FIXME doesn't actually return t.  See last case.
  606. (defun vrml-real-comment-p ()
  607.   "Return t if point is just after the `#' beginning a real comment.
  608. Does not check to see if previous char is actually `#'.
  609. A real comment is either at the beginning of the buffer,
  610. preceded only by whitespace on the line, or has a preceding
  611. semicolon, opening brace, or opening bracket on the same line."
  612.   (save-excursion
  613.     (backward-char)
  614.     (vrml-real-command-p)))
  615.  
  616. (defun vrml-hairy-scan-for-comment (state end always-stop)
  617.   "Determine if point is in a comment.
  618. Returns a list of the form `(FLAG . STATE)'.  STATE can be used
  619. as input to future invocations.  FLAG is nil if not in comment,
  620. t otherwise.  If in comment, leaves point at beginning of comment.
  621. See also `vrml-simple-scan-for-comment', a simpler version that is
  622. often right."
  623.   (let ((bol (save-excursion
  624.            (goto-char end)
  625.            (beginning-of-line)
  626.            (point)))
  627.     real-comment
  628.     last-cstart)
  629.     (while (and (not last-cstart) (< (point) end))
  630.       (setq real-comment nil)        ;In case we've looped around and it is
  631.                                         ;set.
  632.       (setq state (parse-partial-sexp (point) end nil nil state t))
  633.       (if (nth 4 state)
  634.       (progn
  635.         ;; If ALWAYS-STOP is set, stop even if we don't have a
  636.         ;; real comment, or if the comment isn't on the same line
  637.         ;; as the end.
  638.         (if always-stop (setq last-cstart (point)))
  639.         ;; If we have a real comment, then set the comment
  640.         ;; starting point if we are on the same line as the ending
  641.         ;; location.
  642.         (setq real-comment (vrml-real-comment-p))
  643.         (if real-comment
  644.         (progn
  645.           (and (> (point) bol) (setq last-cstart (point)))
  646.           ;; NOTE Emacs 19 has a misfeature whereby calling
  647.           ;; parse-partial-sexp with COMMENTSTOP set and with
  648.           ;; an initial list that says point is in a comment
  649.           ;; will cause an immediate return.  So we must skip
  650.           ;; over the comment ourselves.
  651.           (beginning-of-line 2)))
  652.         ;; Frob the state to make it look like we aren't in a
  653.         ;; comment.
  654.         (setcar (nthcdr 4 state) nil))))
  655.     (and last-cstart
  656.      (goto-char last-cstart))
  657.     (cons real-comment state)))
  658.  
  659. (defun vrml-hairy-in-comment ()
  660.   "Return t if point is in a comment, and leave point at beginning
  661. of comment."
  662.   (let ((save (point)))
  663.     (beginning-of-defun)
  664.     (car (vrml-hairy-scan-for-comment nil save nil))))
  665.  
  666. (defun vrml-simple-in-comment ()
  667.   "Return t if point is in comment, and leave point at beginning
  668. of comment.  This is faster than `vrml-hairy-in-comment', but is
  669. correct less often."
  670.   (let ((save (point))
  671.     comment)
  672.     (beginning-of-line)
  673.     (while (and (< (point) save) (not comment))
  674.       (search-forward "#" save 'move)
  675.       (setq comment (vrml-real-comment-p)))
  676.     comment))
  677.  
  678. (defun vrml-in-comment ()
  679.   "Return t if point is in comment, and leave point at beginning
  680. of comment."
  681.   (if vrml-use-hairy-comment-detector
  682.       (vrml-hairy-in-comment)
  683.     (vrml-simple-in-comment)))
  684.  
  685. (defun vrml-do-fill-paragraph (ignore)
  686.   "fill-paragraph function for VRML mode.  Only fills in a comment."
  687.   (let (in-comment col where)
  688.     (save-excursion
  689.       (end-of-line)
  690.       (setq in-comment (vrml-in-comment))
  691.       (if in-comment
  692.       (progn
  693.         (setq where (1+ (point)))
  694.         (setq col (1- (current-column))))))
  695.     (and in-comment
  696.      (save-excursion
  697.        (back-to-indentation)
  698.        (= col (current-column)))
  699.      ;; In a comment.  Set the fill prefix, and find the paragraph
  700.      ;; boundaries by searching for lines that look like
  701.      ;; comment-only lines.
  702.      (let ((fill-prefix (buffer-substring (progn
  703.                         (beginning-of-line)
  704.                         (point))
  705.                           where))
  706.            p-start p-end)
  707.        ;; Search backwards.
  708.        (save-excursion
  709.          (while (looking-at "^[ \t]*#")
  710.            (forward-line -1))
  711.          (forward-line)
  712.          (setq p-start (point)))
  713.  
  714.        ;; Search forwards.
  715.        (save-excursion
  716.          (while (looking-at "^[ \t]*#")
  717.            (forward-line))
  718.          (setq p-end (point)))
  719.  
  720.        ;; Narrow and do the fill.
  721.        (save-restriction
  722.          (narrow-to-region p-start p-end)
  723.          (fill-paragraph ignore)))))
  724.   t)
  725.  
  726. (defun vrml-do-auto-fill ()
  727.   "Auto-fill function for VRML mode.  Only auto-fills in a comment."
  728.   (if (> (current-column) fill-column)
  729.       (let ((fill-prefix "# ")
  730.         in-comment col)
  731.     (save-excursion
  732.       (setq in-comment (vrml-in-comment))
  733.       (if in-comment
  734.           (setq col (1- (current-column)))))
  735.     (if in-comment
  736.         (progn
  737.           (do-auto-fill)
  738.           (save-excursion
  739.         (back-to-indentation)
  740.         (delete-region (point) (save-excursion
  741.                      (beginning-of-line)
  742.                      (point)))
  743.         (indent-to-column col)))))))
  744.  
  745. (defun vrml-indent-for-comment ()
  746.   "Indent this line's comment to comment column, or insert an empty comment.
  747. Is smart about syntax of VRML comments.
  748. Parts of this were taken from indent-for-comment (simple.el)."
  749.   (interactive "*")
  750.   (end-of-line)
  751.   (or (vrml-in-comment)
  752.       (progn
  753.     ;; Not in a comment, so we have to insert one.  Create an
  754.     ;; empty comment (since there isn't one on this line).
  755.     (skip-chars-backward " \t")
  756.     (let ((eolpoint (point)))
  757.       (beginning-of-line)
  758.       (if (/= (point) eolpoint)
  759.           (progn
  760.         (goto-char eolpoint)
  761.         (insert
  762.          "# ")
  763.         (backward-char))))))
  764.   ;; Point is just after the "#" starting a comment.  Move it as
  765.   ;; appropriate.
  766.   (let* ((indent (funcall comment-indent-function))
  767.      (begpos (progn
  768.            (backward-char)
  769.            (point))))
  770.     (if (/= begpos indent)
  771.     (progn
  772.       (skip-chars-backward " \t" (save-excursion
  773.                        (beginning-of-line)
  774.                        (point)))
  775.       (delete-region (point) begpos)
  776.       (indent-to indent)))
  777.     (looking-at comment-start-skip)    ; Always true.
  778.     (goto-char (match-end 0))
  779.     ;; I don't like the effect of the next two.
  780.     ;;(skip-chars-backward " \t" (match-beginning 0))
  781.     ;;(skip-chars-backward "^ \t" (match-beginning 0))
  782.     ))
  783.  
  784. ;;; vrml-mode.el ends here
  785.